home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / ici / ici.cpi / mem.c < prev    next >
C/C++ Source or Header  |  1994-10-27  |  2KB  |  140 lines
  1. #include "mem.h"
  2. #include "int.h"
  3. #include "buf.h"
  4.  
  5. STATIC long
  6. mark_mem(o)
  7. object_t    *o;
  8. {
  9.     o->o_flags |= O_MARK;
  10.     return sizeof(mem_t);
  11. }
  12.  
  13. STATIC int
  14. cmp_mem(m1, m2)
  15. mem_t    *m1;
  16. mem_t    *m2;
  17. {
  18.     return m1->m_base != m2->m_base
  19.     || m1->m_length != m2->m_length
  20.     || m1->m_accessz != m2->m_accessz
  21.     || m1->m_free != m2->m_free;
  22. }
  23.  
  24. STATIC long
  25. hash_mem(m)
  26. mem_t    *m;
  27. {
  28.     return (long)m->m_base + (long)m->m_length + (long)m->m_accessz;
  29. }
  30.  
  31. STATIC int
  32. assign_mem(m, k, v)
  33. register mem_t    *m;
  34. object_t    *k;
  35. object_t    *v;
  36. {
  37.     register int    i;
  38.  
  39.     if (!isint(k) || !isint(v))
  40.     return assign_simple(objof(m), k, v);
  41.     i = intof(k)->i_value;
  42.     if (i < 0 || i >= m->m_length)
  43.     {
  44.     sprintf(buf, "attempt to write at mem index %d\n", i);
  45.     error = buf;
  46.     return 1;
  47.     }
  48.     switch (m->m_accessz)
  49.     {
  50.     case 1:
  51.     m->m_base[i] = intof(v)->i_value;
  52.     break;
  53.  
  54.     case 2:
  55.     ((short *)m->m_base)[i] = intof(v)->i_value;
  56.     break;
  57.  
  58.     case 4:
  59.     ((long *)m->m_base)[i] = intof(v)->i_value;
  60.     break;
  61.     }
  62.     return 0;
  63. }
  64.  
  65. STATIC object_t *
  66. fetch_mem(m, k)
  67. register mem_t    *m;
  68. object_t    *k;
  69. {
  70.     register long    i;
  71.     register object_t    *o;
  72.  
  73.     if (!isint(k))
  74.     return fetch_simple(objof(m), k);
  75.     i = intof(k)->i_value;
  76.     if (i < 0 || i >= m->m_length)
  77.     return objof(&o_null);
  78.     switch (m->m_accessz)
  79.     {
  80.     case 1:
  81.     i = ((unsigned char *)m->m_base)[i];
  82.     break;
  83.  
  84.     case 2:
  85.     i = ((unsigned short *)m->m_base)[i];
  86.     break;
  87.  
  88.     case 4:
  89.     i = ((long *)m->m_base)[i];
  90.     break;
  91.     }
  92.     o = objof(new_int(i));
  93.     loose(o);
  94.     return o;
  95. }
  96.  
  97. mem_t *
  98. new_mem(base, length, accessz, free_func)
  99. char        *base;
  100. unsigned long    length;
  101. int        accessz;
  102. void        (*free_func)();
  103. {
  104.     register mem_t    *m;
  105.  
  106.     if ((m = talloc(mem_t)) == NULL)
  107.     return NULL;
  108.     objof(m)->o_type = &mem_type;
  109.     objof(m)->o_tcode = TC_OTHER;
  110.     objof(m)->o_flags = 0;
  111.     objof(m)->o_nrefs = 1;
  112.     rego(m);
  113.     m->m_base = base;
  114.     m->m_length = length;
  115.     m->m_accessz = accessz;
  116.     m->m_free = free_func;
  117.     return memof(atom(objof(m), 1));
  118. }
  119.  
  120. STATIC void
  121. free_mem(m)
  122. register mem_t    *m;
  123. {
  124.     if (m->m_free != NULL)
  125.     (*m->m_free)(m->m_base);
  126.     zfree((char *)m);
  127. }
  128.  
  129. type_t    mem_type =
  130. {
  131.     mark_mem,
  132.     free_mem,
  133.     hash_mem,
  134.     cmp_mem,
  135.     copy_simple,
  136.     assign_mem,
  137.     fetch_mem,
  138.     "mem"
  139. };
  140.